// 用户信息逻辑层

// 引入Model层
const { addUsers,delUser,updateUser,queryUsers } = require('../models/user')
// TODO：参数校验

// 引入加密模块
const crypto = require('crypto')
const jwt = require('jsonwebtoken')
const { passwordSecret,tokenSecret } = require('../utils/env')
const { get } = require('https')
const { type } = require('os')

class usersCtl{
    // 登录
    async userLogin(ctx){
        // 校验post参数
        ctx.verifyParams({
            account : { type: 'string' , required: true },
            password : { type: 'string' , required:true }
        })
        // 解构赋值获取账号和密码
        const { account,password } = ctx.request.body
        // 加密密码
        const encryptedPassword = crypto.createHmac('sha256',passwordSecret).update(password).digest('hex')
        // 查询条件信息
        const queryInfo = {
            limitNumber : 1,
            skipNumber : 0,
            field : '_id',
            orderType : 'asc'
        }
        const fieldObj = {
            password : false,
            isDeleted : false
        }
        // 将账号、密码与数据库中用户信息进行比对。
        const nameResult = await queryUsers({
            name : account,
            password : encryptedPassword,
            isDeleted : false
        },queryInfo,fieldObj)
        const phoneResult = await queryUsers({
            phone : account,
            password : encryptedPassword,
            isDeleted : false
        },queryInfo,fieldObj)
        const result = nameResult.concat(phoneResult)
        // 根据数据库中查询到的数据，判断是否登录成功
        if(result.length < 1){
            ctx.body = {
                data:result,
                msg: "账号或密码错误",
                status: 403
            }
        }else{
            const payload = result[0]
            const token = jwt.sign(payload,tokenSecret,{ expiresIn:60*60*24*3})
            ctx.body = {
                data:result[0],
                token: 'Bearer '+token,
                msg: "登录成功",
                status: 200
            }
        }
    }
    // 获取用户信息列表
    async getUsersList(ctx){
        // 解构赋值获取查询条件
        let { query_value,limitNumber,skipNumber,field,orderType } = ctx.request.query
        // 查询条件
        let queryObj = {}
        limitNumber = parseInt(limitNumber)
        skipNumber = parseInt(skipNumber)
        const queryInfo = {
            limitNumber : limitNumber,
            skipNumber : skipNumber,
            field : field,
            orderType : orderType
        }
        const fieldObj = {
            password : false,
            isDeleted : false
        }
        // 查询结果
        let getResult = {}
        // 如果没有值，则查询所有数据
        if( query_value === ''){
            if(ctx.state.user.role > 0){
                queryObj = {
                    role : 1,
                    isDeleted : false
                }
            }else{
                queryObj = {
                    isDeleted : false
                }
            }
            getResult = await queryUsers(queryObj,queryInfo,fieldObj)
        }else{
            // 将账号、手机号与数据库中用户信息进行比对。
            const nameResult = await queryUsers({
                name : query_value,
                isDeleted : false
            },queryInfo,fieldObj)
            const phoneResult = await queryUsers({
                phone : query_value,
                isDeleted : false
            },queryInfo,fieldObj)
            getResult = nameResult.concat(phoneResult)
        }
        ctx.body = {
            data : getResult,
            message : '获取资源列表成功',
            status : 200
        }
    }
    // 创建用户
    async createUser(ctx){
        // 校验post参数
        ctx.verifyParams({
            name : { type: 'string' , required: true },
            password : { type: 'string' , required:true },
            phone : { type: 'number' , required:true },
            role : { type:'number' , required:true }
        })
        // 解构赋值获取用户信息
        const { name,password,phone,role } = ctx.request.body
        // 校验用户名和手机号是否已存在
        const queryInfo = {
            limitNumber : 1,
            skipNumber : 0,
            field : "_id",
            orderType : "desc"
        }
        const queryUserByNameResult = await queryUsers({
            name : name
        },queryInfo,{
            password : false,
            isDeleted : false
        })
        const queryUserByPhoneResult = await queryUsers({
            phone : phone
        },queryInfo,{
            password : false,
            isDeleted : false
        })
        if(queryUserByNameResult.length > 0){
            ctx.body = {
                data : 0,
                message : "用户名已存在",
                status : 403
            }
        }else if(queryUserByPhoneResult.length > 0){
            ctx.body = {
                data : 1,
                message : "手机号已存在",
                status : 403
            }
        }else{
            // 加密密码
            const encryptedPassword = crypto.createHmac('sha256',passwordSecret).update(password).digest('hex')
            // 新建一个对象，存储全部信息
            const userInfo = {
                name : name,
                password : encryptedPassword,
                phone : phone,
                role : role,
                isDeleted : false,
                user_update_time : new Date()
            }
            // 存储到数据库中
            const addUserResult = await addUsers(userInfo)
            ctx.body = {
                data : addUserResult,
                message : '新增用户成功！',
                status : 200
            }
        }
    }
    // 更新用户信息
    async updateUser(ctx){
        // TODO:通过短信校验，实现密码修改
        // 获取用户对应Id
        const { id } = ctx.params
        if(ctx.state.user.role > 0){
            ctx.body = {
                message : "修改失败，当前用户权限不足",
                status : 403
            }
        }else{
            // 校验请求体参数
            ctx.verifyParams({
                updateType : { type : 'string' , required : true },
                name : { type: 'string' , required : false },
                password : { type: 'string' , required : false },
                phone : { type: 'number' , required : false },
                role : { type:'number' , required : false }
            })
            // 解构赋值
            const { updateType } = ctx.request.body
            const queryInfo = {
                limitNumber : 1,
                skipNumber : 0,
                field : "_id",
                orderType : "desc"
            }
            switch(updateType){
                case "name":
                    const { name } = ctx.request.body
                    const queryUserByNameResult = await queryUsers({
                        name : name
                    },queryInfo,{
                        password : false,
                        isDeleted : false
                    })
                    if(queryUserByNameResult.length > 0){
                        ctx.body = {
                            date : 1,
                            message : '修改失败，用户名已存在！',
                            status : 403
                        }
                    }else{
                        const updateInfo = {
                            name : name,
                            user_update_time : new Date()
                        }
                        const updateUserResult = await updateUser(id,updateInfo)
                        ctx.body = {
                            updateNumber : updateUserResult,
                            message : "修改用户名成功！",
                            status : 200
                        }
                    }
                    break
                case "password":
                    const { password } = ctx.request.body
                    // 加密密码
                    const encryptedPassword = crypto.createHmac('sha256',passwordSecret).update(password).digest('hex')
                    const updateInfo = {
                        password : encryptedPassword,
                        user_update_time : new Date()
                    }
                    const updateUserResult = await updateUser(id,updateInfo)
                    ctx.body = {
                        updateNumber : updateUserResult,
                        message : "修改密码成功！",
                        status : 200
                    }
                    break
                case "phone":
                    const { phone } = ctx.request.body
                    const queryUserByPhoneResult = await queryUsers({
                        phone : phone
                    },queryInfo,{
                        password : false,
                        isDeleted : false
                    })
                    if(queryUserByPhoneResult.length > 0){
                        ctx.body = {
                            date : 1,
                            message : '修改失败，手机号已存在！',
                            status : 403
                        }
                    }else{
                        const updateInfo = {
                            phone : phone,
                            user_update_time : new Date()
                        }
                        const updateUserResult = await updateUser(id,updateInfo)
                        ctx.body = {
                            updateNumber : updateUserResult,
                            message : "修改手机号成功！",
                            status : 200
                        }
                    }
                    break
                case "role":
                    const { role } = ctx.request.body
                    if((role > 1)|(role < 0) ){
                        ctx.body = {
                            date : 0,
                            message : "修改用户角色失败，请求参数存在问题！",
                            status : 403
                        }
                    }else{
                        const updateInfo = {
                            role : role,
                            user_update_time : new Date()
                        }
                        const updateUserResult = await updateUser(id,updateInfo)
                        ctx.body = {
                            updateNumber : updateUserResult,
                            message : "修改用户角色成功！",
                            status : 200
                        }
                    }
                    break
                default:
                    ctx.body = {
                        date : 0,
                        message : '修改失败，请求参数存在问题！',
                        status : 403
                    }
            }
        }
    }
    // 删除用户
    async deleteUser(ctx){
        if(ctx.state.user.role > 0){
            ctx.body = {
                message : "删除失败，当前用户权限不足",
                status : 403
            }
        }else{
            // 获取用户对应Id
            const { id } = ctx.params
            // 调用用户删除方法，删除用户
            const deleteUserResult = await delUser(id)
            ctx.body = {
                data : deleteUserResult,
                message : "删除用户信息成功",
                status : 200
            }
        }
    }
}

// 导出用户控制器对象（实例化userCtl类）。
module.exports = new usersCtl()